/**
 * El paquete estadistec.grafico es contenedor de las clases  conformadoras de los componentes gráficos.
 * 
 * Este paquete depende de los siguientes archivos para  su funcionamiento:
 * 
 * 1. config.xml: este se encuentra  en la carpeta res y posee la 
 * funcionalidad de contenener en sus etiquetas de xml 
 * las posiciones(i , y) de cada uno de los componentes gráficos, así como las dimensiones (alto, ancho) de los mismos
 *    Este archivo contiene además la ruta de las imagenes que se utilizan en los componentes que así lo requieran
 *    
 * 2. ConstantesGraficas.java: interface del paqueteGrafico en la contiene 
 * todas aquellas  varibles que son conderadas como 
 *    constantes porque no serán modificados en el tiempo de ejecusión.
 *    
 * 3. Utilidades.java: encargada de extraer los datos del config.xml para el 
 * usado en los diferentes componentes gráficos
 * 
 * 4.Componentes:
 *     4.1  Escritorio
 *     4.2  BarraEscritorio
 *     4.3  BarraHerramientas
 *     4.4  Menuherramientas
 *     4.5  TablaNormal
 *     4.6  VentanaAtributos
 *  
 *  @author pcorrales
 */

package estadistec.grafico;

import estadistec.logica.tabla.LTabla;
import estadistec.logica.parser.Parser;

/*
 * arreglar las importaciones de variables
 */
import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.BorderFactory;
import javax.swing.JInternalFrame;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import javax.swing.JTable;
import java.awt.*;
import java.awt.event.*;
import java.util.ArrayList;

/**
 * Clase encargada de mostrar la estructura gráfica de la tablaNormal. Esta TablaNormal se 
 * encuentra estructurada por dos tablas internas:
 * TablaCasos (en la cual se  simula una matriz casos(filas) y atributos(columnas))
 * y la TablaMedidas( esta es  una tabla de medidas con su respectivo valor)
 * contiene los metodos necesarios para trabajar con los atributos y las medidas
 * permite la creacion, eliminacion, modificacion de los atributos.
 *
 * 2009-11-22: Hay información que ya se encuentre en la parte lógica.
 * Modificando la información.
 */
abstract public class GTabla   extends JInternalFrame   implements ConstantesGraficas, MouseListener, MouseMotionListener,KeyListener
{
	
	
	/* 
	 * declaracion variables
	 */
	
	/***
	 * numero de columnas de la tabla
	 */
	protected int _cantidadColumnas; 
	
	
	/***
	 * numero de filas de la tabla
	 */
	protected int _cantidadFilas; 
	
	/**
	 * arreglo de los objetos que representan la columnbas uniciales de la tabla casos
	 */
	protected Object[] columnas;
	
	
    /**
     * bandera  para indicar que se desea aumentar los casos 
     */
    protected  boolean aumentarCaso;
    
    /**
     * bandera  para indicar que se desea aumentar casos (al posicionarse y escribir en elúltimo caso)
     */
    protected  boolean escribirCaso;
    
    
    /***
     * bandera para indicar que se esta procesando una solicitud de un nuevo atributo
     */
    
     protected boolean solicitud;
    
    /**
     * Escritorio gráfico donde está incluida la tabla.
     */
    protected GEscritorio _escritorioPadre;
	
	
	/*
	 * ************declaracion de componentes graficos********************
	 */
    
	/**
	 * modelo utilizado para las tablaCasos, el cual permite personalizar los eventos de JTable
	 */
	protected DefaultTableModel modeloTablaCasos;
	
	   
	/**
	 * modelo utilizado para las tablaMedidas, el cual permite personalizar los eventos de JTable
	 */
	protected DefaultTableModel modeloTablaMedidas; 
	
	/**
	 * menu para la  tablaCasos 
	 */
    protected  JPopupMenu menuCasos;
    
    /* items, que serán  agregados al menu casos*/
    
    /** opción para modificar las propiedades de un atributo */
    protected  JMenuItem modificarPropiedades; 
    
    /**opción para eliminar un atributo*/
    protected  JMenuItem eliminarAtributo;
    
    /**opción para eliminar un caso*/
    protected  JMenuItem eliminarCaso;
    
    /**opción para eliminar una medida de la tabla medidas*/
    protected  JMenuItem eliminarMedidas; 
    
    /** opción para cambiar el nombre de la TABLA NORMAl sobre la cual se trabaja */
    protected  JMenuItem cambiarNombre;


   /** opción para  modificar el numero de casos(se agregan más casos al final) */
    protected  JMenuItem agregarCasos;
   
    /**
     * menu para la tablaMedida
     */
    protected  JPopupMenu menuMedidas;
    
    /**
     * JTable para trabajar con los casos y los atributos
     */ 
    protected  JTable tabla;
    
    /**
     * JTable para trabajar con las medidas
     */
    protected  JTable  tablaMedidas;
    
    /**
     * panel en el cual  contiene la panelTablaCasos y paneltablaMedidas
     */
    protected  JPanel panelPrincipal;

    /**
     * panel con scroll para  permitir el  aumento  de tamanno de la Jable de Casos
     */
    protected  JScrollPane panelTablaCasos;

    /**
     * panel con scroll para  permitir el  aumento  de tamanno de la Jtable medidas
     */
    protected  JScrollPane panelTablaMedidas;
    
    /**
     * panel  para agregarl los scrollpanel
     */
    protected  JPanel principal;
    
	
	/** 
	 * Tabla l�gica respectiva.
	 */
	protected LTabla _lTabla;
	
	/**
	 * lista de las llaves de los atributos l�gicos
	 */
	
	protected ArrayList<Long>ListaLlaves;
	
	/**
	 * variable para almacenar filas y columnas
	 */
	int column, row,columnM,rowM;
	
	/**
	 * lista de las llaves de los atributos l�gicos
	 */
	protected ArrayList<Long>ListaMedidas;


	/** 
	 * Constructor.
	 * 
	 * @param lTabla Tabla lógica.
	 * @param nombre Nombre de la tabla.
	 */
    public GTabla(LTabla lTabla, String nombre) 
    {
        super(nombre);

		this._lTabla = lTabla;
        
        /* valores iniciales  de las banderas */
        
        aumentarCaso = false;
        escribirCaso = false;
        setValorSolicitud(false);
        
        principal = new JPanel();
    	principal.setLocation(CONFIG.cargarPunto("ORIGEN"));
    	
        /*iniciacion de variables  de la  tabla de casos */
        _cantidadColumnas = COLUMNAS.length;
        _cantidadFilas = COLUMNAS.length;
        
        /* lista de  llaves atributos*/
        ListaLlaves = new ArrayList<Long>();
        
       
         /* modelo para tabla casos y la sobreescritura del método  editable de las columnas */
                 
        modeloTablaCasos = new DefaultTableModel(COLUMNAS,_cantidadFilas)
        {
        	public boolean isCellEditable (int row, int column)
        	   {
        	       /* Aqui devolvemos true o false segçun queramos que una celda
        	       identificada por fila,columna (row,column), sea o no editable o
        	       las celdas no editables seran las de las colunmna 0 y la columna de nuevo*/
        	       if (column == 0  && row > 0)
        	          return false;
        	 
        	       else if(column == modeloTablaCasos.getColumnCount()-1)
        	          return false;
     
        	       return true;
        	   }
        };
        
  	 	
  	 	/*  inicializar tabla casos */
  	 	
  	 	tabla = new JTable(modeloTablaCasos);
  	 	tabla.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  	 	tabla.getTableHeader().setReorderingAllowed(false);
  	 	
 
  	 	/* inicializar tabla  medidas */
  		modeloTablaMedidas =  new DefaultTableModel(COLUMNAS2,1);
  	 	tablaMedidas = new JTable(modeloTablaMedidas);
  	 	tablaMedidas.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
  	 	
  	  
  	    /* inicializar Menu casos */
  	    menuCasos = new JPopupMenu();
  	    
  	    /* inicilizar  items del menu casos y poner sus etiquetas  */
  	 	modificarPropiedades = new JMenuItem("Modificar Propiedades");
        cambiarNombre = new JMenuItem("Cambiar nombre tabla");
        eliminarCaso = new JMenuItem("Eliminar caso(s)");
        eliminarAtributo = new JMenuItem("Eliminar atributo(s)");
        agregarCasos = new JMenuItem("Agregar caso(s)");
        
  	 	/* agregar los componentes al menu caso */
        menuCasos.add(modificarPropiedades);
        menuCasos.add(cambiarNombre);
        menuCasos.add(eliminarCaso);
        menuCasos.add(eliminarAtributo);
        menuCasos.add(agregarCasos);
        
    	/*
    	 * agregar a la tabla casos el menucasos
    	 */
  	 	tabla.setComponentPopupMenu(menuCasos);
  	 	
  	  
        /*
         * inicializar menu  para la Jtable medidas
         */
        menuMedidas= new JPopupMenu();
        
        
        /*
         *items del menu medidas
         */
        eliminarMedidas = new JMenuItem("Eliminar medidas");
        
        /*
         * agregar a la tabla medidas el menu medidas
         */
        tablaMedidas.setComponentPopupMenu(menuMedidas);
  
        
  	 	/*
  	 	 * valores fijos en cuanto a ancho  para la columna de  los casos( column 0)
  	 	 */
  	 	tabla.getColumnModel().getColumn(0).setPreferredWidth(CELDACASOS_PREFEREN);
  	 	tabla.getColumnModel().getColumn(0).setMinWidth(CELDACASOS_MIN);
		tabla.getColumnModel().getColumn(0).setMaxWidth(CELDACASOS_MAX);
	
		
		/*
		 * inicializar las  demas columnas con los valores establecidos para sus tamanos
		 */
  	 	for(int contador = 1 ; contador < _cantidadColumnas; contador++)
  	 	{
  	 		tabla.getColumnModel().getColumn(contador).setPreferredWidth(CELDANORMAL_PREFEREN );
  		    tabla.getColumnModel().getColumn(contador).setMaxWidth(CELDANORMAL_MAX );
  		    tabla.getColumnModel().getColumn(contador).setMinWidth(CELDANORMAL_PREFEREN );
  		    tabla.setValueAt(String.valueOf(VALORCOLUMNAS[contador]),0,contador);	 	 
  	 	}
	 
        /* 
         * inicializar scroll panel para la tabla casos,carga las dimenciones desde el archivo config.xml
         */
  	 	
		panelTablaCasos= new JScrollPane(tabla);
		panelTablaCasos.setBorder(BorderFactory.createTitledBorder("Casos"));
		panelTablaCasos.setVisible(true);
		
		/*
		 * inicializar  scroll para la tabla de medidas, carga las dimenciones desde el archivo config.xml
		 */
		panelTablaMedidas =  new JScrollPane(tablaMedidas);
		panelTablaMedidas.setBorder(BorderFactory.createTitledBorder("Medidas"));
		panelTablaMedidas.setVisible(true);
		

		panelPrincipal = new JPanel(null);
		panelPrincipal.setLocation(CONFIG.cargarPunto("PANEL_TABLA"));
		panelPrincipal.setSize(CONFIG.cargarDimension("PANEL_TABLA"));
		panelPrincipal.setVisible(true);

		tabla.addMouseMotionListener(this);
		tabla.addMouseListener(this);
		tabla.addKeyListener(this);
		tablaMedidas.addMouseMotionListener(this);
		tablaMedidas.addMouseListener(this);
		tablaMedidas.addKeyListener(this);

		eliminarMedidas.addMouseListener(this);
        modificarPropiedades.addMouseListener(this);
        cambiarNombre.addMouseListener(this);
        eliminarCaso .addMouseListener(this);
        eliminarAtributo.addMouseListener(this);
        agregarCasos.addMouseListener(this);
        
       /* administrador de diseno   */
        principal.setLayout(new GridLayout(2,1));
	    principal.add(panelTablaCasos);
	    principal.add(panelTablaMedidas);
	    
	    /*eventos sobre ventanas internar(cerrar, maximizar,aumentar,disinuir)*/
	    this.setClosable(true);
	    this.setMaximizable(true);
	    this.setResizable(true);
		this.setIconifiable(true);
		this.add(principal);
		
		/*poner  la numeracion a los casos*/
		colocarNumeracion();
     }
     
    
     /**
      * Evento para cuando se presiona una tecla.
      */
     public void keyPressed(KeyEvent k) 
     {keyTyped(k);
     }
     
     /**
      * Evento para cuando se digita una tecla.
      * toma los valores de la tabla(fila,columna) en la cual se escribe
      */
     public void keyTyped(KeyEvent k) {   }

     /**
      * Evento para cuando se suelta la tecla enter. Lo que hace leer el numero de casos.
      */
     public void keyReleased(KeyEvent k) 
	 {   
		 String valor = "";
		 
		 try
		 {
			 if(k.getKeyCode() == 10)
			 { 
				 if(k.getSource() == this.tabla)
				 {
					 column =  tabla.getSelectedColumn();
					 row = tabla.getSelectedRow();
					 if(column == 0 && row == 0)
					 {
						 valor = this.tabla.getValueAt(row,column).toString();
						 System.out.println(tabla.getValueAt(0,1).toString());
						 modificarNumeroCasos();
												 		 
					 }
					 else if (row != 0 && column != 0)
					 {
						 // Obteniendo el valor en la celda.
						 valor = this.tabla.getValueAt(row,column).toString();
						 modificarCasos_Atributo(row, column, valor);
					 }
				 }
				 else if(k.getSource() == this.tablaMedidas)
				 {
					 columnM =  tablaMedidas.getSelectedColumn();
					 rowM = tablaMedidas.getSelectedRow();
					 if(columnM == 0 &&  rowM >= 0)
					 {
					    valor = tablaMedidas.getValueAt(rowM,columnM).toString();
					    System.out.println(rowM);
					    System.out.println(columnM);
					    
					    if(!valor.equals(""))
					    {
					    	solicitarDatosMedidas();
					    }
					 }
				 }					 
			 } 
		 }
		 catch(Exception e)
		 {
			 System.out.println("toma valor nulo");
			 System.out.println(rowM);
			 System.out.println(columnM);
			 e.printStackTrace();
		 }
	 }


     
     /** 
      * @todo  arrastrar para poder aumentar o disminuir las filas de las tabla (casos)
      */
     
     /*
      *eventos del mouse
      */
     public void mouseDragged(MouseEvent e){}
     public void mouseMoved   (MouseEvent e) {} 
     public void mouseReleased(MouseEvent e) {}
     public void mouseExited(MouseEvent e) {}
     
     
     public void mousePressed (MouseEvent e)
	 {
         /* solicitar el cambiar el nombre de la tabla*/
    	 
    	 if(e.getSource() == cambiarNombre)
    	 {  
    		/* solicitar el nombre de la tabla y envairlo a verificar */
    		 Frame f = new JFrame() ;
   		     f.setBackground( Color.blue );
    		 String nombreTabla = JOptionPane.showInputDialog(f,
					 "Ingrese el nombre de la tabla",
					 "Nombre de la Tabla", JOptionPane.QUESTION_MESSAGE);
    		 this.cambiarNombre(nombreTabla);
    		 
    	 }
    	 /* opcion para  modificar propiedades de un atributo*/
    	 else if (e.getSource() == modificarPropiedades)
    	 {
              int x = tabla.getSelectedColumn();
   		      String nombre = "";
   		      System.out.println("....");
	   		  System.out.println(x);
	   		  System.out.println("...");
	   		  nombre =  tabla.getValueAt(0,x).toString();
	   		  VentanaModificarAtributo ventanita = new VentanaModificarAtributo(nombre);  
	   		  ventanita.setLocation(CONFIG.cargarPunto("VENTANA_ATRIBUTOS"));
	   		  ventanita.setSize(CONFIG.cargarDimension("VENTANA_ATRIBUTOS"));
	   		  ventanita.iniciar();
	   		  //_gEscritorio.add(ventanita);
    		 
    	 }
    	 
    	 /*opcion para eliminar un atributo*/
    	 else if (e.getSource() == eliminarAtributo)
    	 {
    		 System.out.println(modeloTablaCasos.getColumnCount());
    		 
    		 /**se eliminan columnas solo cuando hayan sido definidos casos*/
    		 if(modeloTablaCasos.getColumnCount()> 2 )
    		 {
    			 System.out.println(modeloTablaCasos.getColumnCount());
    		     tabla.removeColumn(tabla.getColumnModel().getColumn(tabla.getSelectedColumn()));
    		     modeloTablaCasos.setColumnCount(modeloTablaCasos.getColumnCount()-1);
    		     colocarNumeracion();
    		 }
    	 }
    	 /*opcion para eliminar un c*/
    	 else if (e.getSource() == eliminarCaso)
    	 {
    		 System.out.println("eliminar una fila");
    		 modeloTablaCasos.removeRow(tabla.getSelectedRow()+1);
    		 //tabla.removeRowSelectionInterval(2,4);
    		 //tabla.remove(tabla.getSelectedRow()+1);
    		 System.out.println("---------");
             System.out.println(tabla.getRowCount());
             System.out.println(tabla.getSelectedRow());
    		 colocarNumeracion();
    		
    	 }
    	 else if (e.getSource() ==  agregarCasos)
    	 {
    		 agregarCasosMenuContextual();
    	 }
    	 
     }	
     
     public void mouseEntered (MouseEvent e) 
     {
    	 
     }
     
     
	 /** 
	  * Eventos para esta tabla.
	  * 
	  * @param e Evento.
	  *
	  * @todo Falta parte al final.
	  */
     public void mouseClicked (MouseEvent e) 
     {    
     	  if(e.getSource() == tabla)
     	  {	 
     	  
     		/*
     		 * Al hacer click sobre la ultima columna(Nuevo) para solcitar la creación
     		 * de  un nuevo atributo, mediante la ventana de solictudes
     		 */
     		if (tabla.getSelectedColumn() == modeloTablaCasos.getColumnCount() - 1 && tabla.getSelectedRow() < 1)
 			{
 			 	solicitudDatos_Atributo(); 
 			}
     		
     		/*
     		 * al hacer click sobre 
     		 */
     		else if(tabla.getSelectedRow() == (this._lTabla.getNoCasos()+1))
    		{
     			//_cantidadFilas++;
     			//modificarNumeroCasosAux(_cantidadFilas);
     		}
     	 }
    }  
      
     
     /**
      * Método  encargado de recorrer la tabla y le agrega la numeración
      * a cada uno de los casos asi como coloca en  celda el núm de casos 
      * existentes.
      */ 
     protected void colocarNumeracion()
     {
    	
    	
    	 /* actualizar el num de casos  */
		 int noCasos = this._lTabla.getNoCasos();
		 int noAtributos = this._lTabla.getNoAtributos();
		 
		 
		 System.out.println("NUM CASOS");
    	 
		 System.out.println(noCasos);
    	 

		 tabla.setValueAt(String.valueOf(noCasos), 0, 0);
	   	 tabla.setValueAt("->", noCasos+1,0);
	 
	     /*
	 	  * recorrer la tabla y colocar la numeracion correspondiente al caso
	 	  */
	 	 for(int x = 1; x <= noCasos; x++)
    		 tabla.setValueAt(String.valueOf(x),x, 0);
	 	 
	 	 for(int x = 1; x <= noAtributos;x++)
	 	    tabla.setValueAt(" ",noCasos+1,x);
     }
     
    
     
     /**
      * @todo se debe de crear una función  que evalue si la expresión cumple con las reglas de nomenclatura de tabla
      */
     
     /**
      * Método encargado de realizar la modificación del nombre, 
      * lo caul lo realizar si al evaluar  el nombre se comprueba 
      * que  este cumple con el formato establecido 
	  *
      * @param nuevoNombre
	  *            nombre de la TablaNormal
	  * @throws Exception
	  *             formato incorrecto del nombre
	  *
	  * @todo Paula: Necesito que crees ventanas de información al usuario
	  * para cada caso del switch.
	  *
	  * @todo  agregar la excepcion correspondiente a error en formato
	  * en la parte de nombre.
	  */
	 public void cambiarNombre(String nuevoNombre)
	 {
		 // Para mensajes de error.
		 Frame f = new JFrame();
		 f.setBackground( Color.blue );
		 if (this.verificarSintaxisNombre(nuevoNombre)) {
			 if (this._lTabla.verificarNombreTablaSinRepetir(nuevoNombre)) {
				 // Asigna el nombre a la tabla.
				 this.setTitle(nuevoNombre); 
				 this._lTabla.setNombre(nuevoNombre);
			 
			 }
			 else
				 JOptionPane.showMessageDialog(f,"Error en nombre: Nombre repetido." ) ;
		 }
		 else
			 JOptionPane.showMessageDialog(f,"Error en nombre: Sintaxis incorrecta." ) ;
	 }

	 public boolean verificarNombreTablaSinRepetir(String nombre) {
		 return (this._lTabla.existeManejableXNombre(nombre));
	 }
     
     /**
      * M�todo para invocar una instancia de la clase AtributosVentana
      * la cuales la encargada de solicitar y validar los datos para crear
      * un nuevo atributo.
      */
     public void solicitudDatos_Atributo()
     {
    	 
    	
    	  /*
		   * invoco la ventana para solicitar los datos del nuevo atributo
		   */
    	   
		   AtributosVentana ventana = new AtributosVentana(this);
		   ventana.setLocation(CONFIG.cargarPunto("VENTANA_ATRIBUTOS"));
		   ventana.setSize(CONFIG.cargarDimension("VENTANA_ATRIBUTOS"));
		   ventana.iniciar();
		   
		   
		  
	      // mostrar en el escritorio la ventana
		   _escritorioPadre.add(ventana);     
		
     } 
     
     
	 /** 
      * Metodo auxiliar para modificar el número de casos de la tabla.
	  * Se especifica el numero total de casos, y se calcula la diferencia
	  * que se debe agregar al final o quitar del final.
	  * 
	  * @param noCasosNuevo Nuevo numero de casos de la tabla.
	  */
     
     public void modificarNumeroCasosAux(int noCasosNuevo)
     {
		 assert (noCasosNuevo >= 0);
		 int noCasosActual = this._lTabla.getNoCasos();
		 
    	 if (noCasosNuevo  > noCasosActual)
         {	
    	    assert(this._lTabla.getNoAtributos() > 0);
         	int noCasosAgregar = Math.min(noCasosNuevo,this._lTabla.maxNoCasosInsertar()) - noCasosActual;
			// Se agregan las filas necesarias.
			modeloTablaCasos.setNumRows(noCasosAgregar + noCasosActual + 2);
			// Se inserta el número de casos.
			this._lTabla.insertarCasos(noCasosActual, noCasosAgregar);
         }
    	 
         /*
          * dismunuir la cantidad de casos
          */
    	 
         else if (noCasosNuevo < noCasosActual)
         {
            System.out.println("Eliminar Casos");
            
         	modeloTablaCasos.setNumRows(noCasosNuevo + 2);
			this._lTabla.eliminarCasos(noCasosNuevo + 1,noCasosActual - noCasosNuevo);		
			
         }
     }
     
     
     /**
      *  Método encargado de modificar en forma dinámica el número de casos 
      *  en la  tabla de casos (ya sea  disminuir o aumentar el numero de casos)
      * 
	  * @throws Exception
	  *             formato incorrecto del numero
	  *
	  * @todo   agregar la Exepcion  de formato de numero
	  */
  
     public void modificarNumeroCasos()
     {
         int noCasos = 0;
         
         /* toma el numero de casos de la celda total casos*/
         try
         {  
             noCasos = Integer.parseInt(tabla.getValueAt(0,0).toString());
         }
         catch(Exception exepcion) 
         {
             JOptionPane.showMessageDialog(null,"El valor ingresado no es un número entero.");
             return;
         }
         if (noCasos < 0)
         {
             JOptionPane.showMessageDialog(null,"El número de casos no debe ser negativo.");
             tabla.setValueAt(this._lTabla.getNoCasos(), 0, 0);
         }
         else if (this._lTabla.getNoAtributos() == 0)
         {
             JOptionPane.showMessageDialog(null,"Sin atributos no se pueden agregar casos.");
         	 tabla.setValueAt(0, 0, 0);
         }
         //modifica el num de casos
         else
         {
             modificarNumeroCasosAux(noCasos);
             colocarNumeracion();
         }
     }
     
     
	 /** 
	  * Mediante menu contextual se solicita agregar un numero de casos
	  * específico.
	  *
	  * @todo Falta determinar el índice a partir del cual se agregan
	  * los casos.
	  */
     public void agregarCasosMenuContextual()
     {
    	 if(this._lTabla.getNoAtributos() > 0)
    	 {
    		 System.out.println(this._lTabla.getNoAtributos());
    	 
		    	 String cantidad = JOptionPane.showInputDialog(null,"Ingrese el numero de casos a agregar:","Agregar casos...",JOptionPane.QUESTION_MESSAGE);
				 int cantidadCasos = 0;
				 try {
					 cantidadCasos = Integer.parseInt(cantidad);
				 } catch (Exception e) {
						 JOptionPane.showMessageDialog(null,"El numero de casos no corresponde a una expresión válida.");
						 agregarCasosMenuContextual();
						 return;
				 }
		
				 if (cantidadCasos <= 0) {
						 JOptionPane.showMessageDialog(null,"El número de casos debe ser positivo.");
						 agregarCasosMenuContextual();
						 return;
				 }
			     
			     // cantidadCasos +=  modeloTablaCasos.getRowCount() - 2;
		    	 modificarNumeroCasosAux(cantidadCasos);
		    	 colocarNumeracion();
    	 }
    	 else
    	 {
    		 JOptionPane.showMessageDialog(null,"La cantidad de atributos debe ser mayor a cero."); 
    	 }	 
     }

     /**
      * M�todo para agregar a la tabla el escritorio padre
      */
     public void agregarGEscritorio(GEscritorio padre)
     {
       this._escritorioPadre = padre;
     }
     
     
     /**
      * M�todo para hacer visible la ventana y a la vez redimencionabla
      */
     public void iniciar()
     {
    	 this.setVisible(true);
     }
     
     /**
      * Método para hacer invisible la ventana y a la vez redimencionabla
      */
     public void finalizar()
     {
    	this.setVisible(false) ;
     }
     
     /**
      * Método para retornar la llave  de la tabla
      * @return llave
      */
     public long getLlave()
     {
    	 return _lTabla.getLlave();
     }
     
     /***
      * M�todo para cambiar el valor de la solicitud e indicar 
      * que se esta solocitando la ventana atributos para agregar un nuevo atributo(true)
      * o bien que se ya no va a usar más (false)
      * @param   bandera
      *   valor booleano  el cual  indica si la ventana atributos esta activa o no
      */
     
     public void setValorSolicitud(boolean bandera)
     {
          solicitud = bandera;
     }
     
     /***
      * M�todo para retornar el valor de la bandera solicitud
      * o bien que se ya no va a usar más (false)
      * @return  bandera
      *   valor booleano el cual  indica si la ventana atributos esta activa o no
      */
     public boolean getValorSolicitud()
     {
          return  solicitud;
     }

	 /** 
	  * Verifica la sintaxis del nombre. Se utiliza para que la
	  * ventana de Atributos pueda verificar el nombre.
	  */
	 public boolean verificarSintaxisNombre (String nombre) {
		 return (this._lTabla.verificarSintaxisNombre(nombre));
	 }

	 /**
	  * Verifica que el nombre de un atributo no esté repetido. Se utiliza
	  * para verificar el nombre de la ventana para crear nuevos atributos.
	  */
	 public boolean verificarNombreAtributoSinRepetir(String nombre) 
	 {
		 return (this._lTabla.existeManejableXNombre(nombre) == false);
	 }

	 /**
	  * Solicitud de creacion de un atributo booleano por la ventana
	  * de crear atributos.
	  */
	 public void agregarAtributoBooleano(String nombre)
	 {
		 this._lTabla.agregarAtributoBooleano(nombre);
	 }

	 public void agregarAtributoBooleano(String nombre, Parser formula, String formulaUsuario)
	 {
		 this._lTabla.agregarAtributoBooleano(nombre, formula, formulaUsuario);
	 }

	 /**
	  * Solicitud de creacion de un atributo entero por la ventana
	  * de crear atributos.
	  */
	 public void agregarAtributoEntero(String nombre) 
	 {
		 this._lTabla.agregarAtributoEntero(nombre);
	 }
	 
	 public void agregarAtributoEntero(String nombre, Parser formula, String formulaUsuario) {
		 this._lTabla.agregarAtributoEntero(nombre, formula, formulaUsuario);
	 }

	 /**
	  * Solicitud de creación de un atributo flotante por la ventana
	  * de crear atributos.
	  */
	 public void agregarAtributoFlotante(String nombre, int noDecimales) {
		 this._lTabla.agregarAtributoFlotante(nombre, noDecimales);
	 }

	 public void agregarAtributoFlotante(String nombre, int noDecimales, Parser formula, String formulaUsuario) {
		 this._lTabla.agregarAtributoFlotante(nombre, noDecimales, formula, formulaUsuario);
	 }
	 
	 /**
	  * Solicitud de creación de un atributo de tipo Intervalo por la ventana
	  * de crear atributos.
	  */
	 public void agregarAtributoIntervalo(String nombre, int noDecimales) {
		 this._lTabla.agregarAtributoIntervalo(nombre, noDecimales);
	 }

	 public void agregarAtributoIntervalo(String nombre, int noDecimales, Parser formula, String formulaUsuario) {
		 this._lTabla.agregarAtributoIntervalo(nombre, noDecimales, formula, formulaUsuario);
	 }

	 /**
	  * Solicitud de creacion de un atributo cualitativo por la ventana
	  * de crear atributos.
	  */
	 public void agregarAtributoCualitativo(String nombre, String[] espacioMuestral) {
		 this._lTabla.agregarAtributoCualitativo(nombre, espacioMuestral);
	 }

	 public void agregarAtributoCualitativo(String nombre, Parser formula, String formulaUsuario) {
		 this._lTabla.agregarAtributoCualitativo(nombre, formula, formulaUsuario);
	 }

	 /** 
	  * Agrega un atributo gr�fico.
	  * 
	  * @param nombre Nombre del atributo a mostrar en la tabla.
	  * @param llave Clave para acceder al atributo mediante _lTabla.
	  * @param valores String de valores a colocar en el atributo.
	  * Se asume que el numero de elementos es menor o igual al número
	  * de casos. Podra no tener ning�n elemento.
	  */
	 public void agregarAtributoGrafico(String nombre, long llave, String[] valores) 
	 {
		 assert(valores.length <= this._lTabla.getNoCasos());
		 
		/* numero de atributos en la tabla lógica**/
		 int numAtributos = this._lTabla.getNoAtributos();
		 
		/* numero de casos en la tabla lógica**/
		 int numCasos = this._lTabla.getNoCasos();
		
		
		/* cantidad de columnas reales en la Jtable**/
		_cantidadColumnas =  modeloTablaCasos.getColumnCount();
	
		 try
		 {
			/*aumentar el num de casos para recorreer uno más */
			numAtributos++;
	
		    _cantidadColumnas++;
		    modeloTablaCasos.setColumnCount( _cantidadColumnas);
		    
		    /* agregar  la llave del nuevo atributo*/
		   
		    ListaLlaves.add(llave);
		    
		    System.out.println("-GTabla AGREGO ATRIBUTO-");
		   
		   //---cambiar el header de las columnas 
		   for(int x = 1; x< numAtributos; x++)
		   {
			   this.tabla.getColumnModel().getColumn(x).setHeaderValue("");	
		   }
		   
		   //--->cambiar el header de la  columna para nuevo	   
		   this.tabla.getColumnModel().getColumn(numAtributos).setHeaderValue("Nuevo");	
		   this.tabla.setValueAt(nombre,0,numAtributos -1);
		   
		   
		   //--->recorrer la  las celdas de casos asociadas a ese atributo
		   for(int x = 0;x< numCasos;x++)
		   {
			   //this.tabla.getColumnModel().getColumn(_cantidadColumnas-2).setHeaderValue(valores[i-1]);
			   this.tabla.setValueAt(valores[x], x+1, _cantidadColumnas-2);
		   }
		  
		}
		catch (Exception e)
		{
				System.out.println(e.getMessage());
		}	 
    }
	 
	 /***
	  * M�todo para modificarCeldas de un atributo
	  * @param fila en JTable
	  *        columna de la JTable
	  *        String valor ingresado por el usuario
	  */
	 public void modificarCasos_Atributo(int fila, int columna, String valor )
	 {
		     System.out.println("--modificar atributo-");
		     Long llaveAtributo = ListaLlaves.get(columna - 1);

		     String nuevoValor = null;
			 
		     if( ! (this._lTabla.esAtributoIndependiente(llaveAtributo)))
			 {
				 int respuesta =  JOptionPane.showConfirmDialog(null,
						    "Desea independizar el atributo?",
						    "Atributo dependiente",
						    JOptionPane.YES_NO_OPTION);
				 
				 //desea modificar el atributo
				 if (respuesta  == JOptionPane.YES_OPTION)
				 {
					 this._lTabla.independizarAtributo(llaveAtributo);
				 }
				 
				 // No desea modificar el atributo, por lo que se recobra
				 // el valor que antes poseia.
				 else
				 {
					nuevoValor = this._lTabla.getTextoValor(llaveAtributo,fila);
					this.modeloTablaCasos.setValueAt(nuevoValor, fila, columna);
					return;
				 }
			 }
			 nuevoValor = this._lTabla.setValor(llaveAtributo,valor,fila);
				 
			 if (nuevoValor == null)
			 {
				 JOptionPane.showMessageDialog(null,
						 "El valor ingresado '"+valor+"' es incorrecto.",
						 "Error de tipo",
						 JOptionPane.ERROR_MESSAGE);
				 this.modeloTablaCasos.setValueAt("", fila, columna);
			 }
			 else
			 {
				 this.modeloTablaCasos.setValueAt(nuevoValor, fila, columna);
			 }
	 }

	 /***
	  * metodo para crear el parser del atribito, encapsula el parser
	  * @return  Parser
	  */
	 public Parser nuevaFormula() 
	 {
		 return (new Parser(this._lTabla));
	 }

	 
	 /** M�todo para actualizar los valores  para cada una de las celdas de los casos
	  *  @param  llave del atributo
	  *          valores nuevos a actualizar  
	  *  @return
	  */
	 
	 public void actualizarValores(Long llave, String[] valores) 
	 {
	       assert(valores.length <= this._lTabla.getNoCasos());
			 
			/* numero de casos en la tabla logica**/
			int noCasos = this._lTabla.getNoCasos();
			
			/*indice de la llave -> nos indica a cual colum modificar */
			int colum =  ListaLlaves.indexOf(llave) + 1;
      
			/* cantidad de columnas reales en la Jtable**/
			 try
			 {   
			   //--->recorrer la  las celdas de casos asociadas a ese atributo
			   for(int i = 0; i < noCasos; i++)
				   this.tabla.setValueAt(valores[i], i+1, colum);
			}
			catch (Exception e)
			{
					System.out.println(e.getMessage());
			}	   
	 }
	 
	 /** Metodo para modoficar las medidas
	  * invoca la creacion a nivel grafico de una medida*/
	 
	 protected void solicitarDatosMedidas()
	 {
		 
		 MedidasVentana  vMedidas = new MedidasVentana(this);
		 vMedidas.iniciar();
		 vMedidas.setLocation(CONFIG.cargarPunto("VENTANA_ATRIBUTOS"));
		 vMedidas.setSize(CONFIG.cargarDimension("VENTANA_ATRIBUTOS"));
		
		 // mostrar en el escritorio la ventana
		  _escritorioPadre.add(vMedidas);     
	 }
	 
	 
	 /**
	  * Metodo encargado de crear la nueva medida en la tabla de medidas.
	  * @param llave de la medida.
	  * @valor  resultado de la formula.
	  */
	 
	 protected void crearMedidaGrafica(long llave, String valor)
	 {
		 int noMedidas= 0;
		 //int noMedidas = this._lTabla.getNoMedidas();
		 ListaMedidas.add(llave);
		
		 this.modeloTablaMedidas.setNumRows(noMedidas++);
		 this.tablaMedidas.setValueAt(valor,noMedidas, 1);	 
		 
	 }

	 /**
	  * M�todo encarga de modificar el valor de una  medida en la tabla de medidas
	  * @param llave de la medida
	  * @valor  resultado de la formula*/
	 
	 protected void actualizarMedidas(long llave, String valor)
	 {
	     int indice = ListaMedidas.indexOf(llave);
	     this.tablaMedidas.setValueAt(valor,indice, 1);	
	 }
}
